Fix all of Clippy’s len_zero warnings.
fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
let overrides = try!(self.query_overrides(dep));
- let ret = if overrides.len() == 0 {
+ let ret = if overrides.is_empty() {
// Ensure the requested source_id is loaded
try!(self.ensure_loaded(dep.source_id(), Kind::Normal));
let mut ret = Vec::new();
candidates.sort_by(|a, b| {
b.version().cmp(a.version())
});
- if candidates.len() > 0 {
+ if !candidates.is_empty() {
msg.push_str("\nversions found: ");
for (i, c) in candidates.iter().take(3).enumerate() {
if i != 0 { msg.push_str(", "); }
// update`. In this case try to print a helpful error!
if dep.source_id().is_path() &&
dep.version_req().to_string().starts_with("=") &&
- candidates.len() > 0 {
+ !candidates.is_empty() {
msg.push_str("\nconsider running `cargo update` to update \
a path dependency's locked version");
(!use_default || prev.contains("default") ||
!has_default_feature)
}
- None => features.len() == 0 && (!use_default || !has_default_feature)
+ None => features.is_empty() && (!use_default || !has_default_feature)
}
}
// they should have all been weeded out by the above iteration. Any
// remaining features are bugs in that the package does not actually
// have those features.
- if feature_deps.len() > 0 {
+ if !feature_deps.is_empty() {
let unknown = feature_deps.keys().map(|s| &s[..])
.collect::<Vec<&str>>();
- if unknown.len() > 0 {
+ if !unknown.is_empty() {
let features = unknown.connect(", ");
bail!("Package `{}` does not have these features: `{}`",
parent.package_id(), features)
}
// Record what list of features is active for this package.
- if used_features.len() > 0 {
+ if !used_features.is_empty() {
let pkgid = parent.package_id();
self.resolve.features.entry(pkgid.clone())
.or_insert(HashSet::new())
// If we have a spec, then we need to delete some packages, otherwise, just
// remove the whole target directory and be done with it!
- if opts.spec.len() == 0 {
+ if opts.spec.is_empty() {
return rm_rf(&target_dir);
}
vec![root_package.package_id()]
};
- if spec.len() > 0 && invalid_spec.len() > 0 {
+ if !spec.is_empty() && !invalid_spec.is_empty() {
bail!("could not find package matching spec `{}`",
invalid_spec.connect(", "))
}
let mut lib_names = HashSet::new();
let mut bin_names = HashSet::new();
- if options.compile_opts.spec.len() == 0 {
+ if options.compile_opts.spec.is_empty() {
for target in package.targets().iter().filter(|t| t.documented()) {
if target.is_lib() {
assert!(lib_names.insert(target.crate_name()));
let mut registry = PackageRegistry::new(opts.config);
let mut to_avoid = HashSet::new();
- if opts.to_update.len() == 0 {
+ if opts.to_update.is_empty() {
to_avoid.extend(previous_resolve.iter());
} else {
let mut sources = Vec::new();
}
}
- if bins.len() == 0 {
+ if bins.is_empty() {
to_remove.extend(installed.get().iter().map(|b| dst.join(b)));
installed.get_mut().clear();
} else {
installed.get_mut().remove(bin);
}
}
- if installed.get().len() == 0 {
+ if installed.get().is_empty() {
installed.remove();
}
}
}
}
}
- assert!(ret.len() > 0);
+ assert!(!ret.is_empty());
Ok(ret)
}
None => {
let &(ref output, ref deps) = &cx.build_explicit_deps[unit];
- let local = if deps.len() == 0 {
+ let local = if deps.is_empty() {
let s = try!(pkg_fingerprint(cx, unit.pkg));
LocalFingerprint::Precalculated(s)
} else {
let write_fingerprint = Work::new(move |_| {
if let Some(output_path) = output_path {
let outputs = state.outputs.lock().unwrap();
- if outputs[&key].rerun_if_changed.len() > 0 {
+ if !outputs[&key].rerun_if_changed.is_empty() {
let slot = MtimeSlot(Mutex::new(None));
fingerprint.local = LocalFingerprint::MtimeBased(slot,
output_path);
// and then immediately return.
loop {
while self.active < self.jobs {
- if queue.len() > 0 {
+ if !queue.is_empty() {
let (key, job, fresh) = queue.remove(0);
try!(self.run(key, fresh, job, config, scope));
} else if let Some((fresh, key, jobs)) = self.queue.dequeue() {
}
}
- if self.queue.len() == 0 {
+ if self.queue.is_empty() {
Ok(())
} else {
debug!("queue: {:#?}", self.queue);
let mut errors = try!(run_unit_tests(options, test_args, &compilation));
// If we have an error and want to fail fast, return
- if errors.len() > 0 && !options.no_fail_fast {
+ if !errors.is_empty() && !options.no_fail_fast {
return Ok(Some(CargoTestError::new(errors)))
}
}
errors.extend(try!(run_doc_tests(options, test_args, &compilation)));
- if errors.len() == 0 {
+ if errors.is_empty() {
Ok(None)
} else {
Ok(Some(CargoTestError::new(errors)))
let mut filter = |p: &Path| {
let relative_path = util::without_prefix(p, &root).unwrap();
include.iter().any(|p| p.matches_path(&relative_path)) || {
- include.len() == 0 &&
+ include.is_empty() &&
!exclude.iter().any(|p| p.matches_path(&relative_path))
}
};
let mut summaries = try!(self.summaries(dep.name())).iter().map(|s| {
s.0.clone()
}).collect::<Vec<_>>();
- if try!(summaries.query(dep)).len() == 0 {
+ if try!(summaries.query(dep)).is_empty() {
try!(self.do_update());
}
}
/// `None` is returned then no packages are ready to be built.
pub fn dequeue(&mut self) -> Option<(Freshness, K, V)> {
let key = match self.dep_map.iter()
- .find(|&(_, &(ref deps, _))| deps.len() == 0)
+ .find(|&(_, &(ref deps, _))| deps.is_empty())
.map(|(key, _)| key.clone()) {
Some(key) => key,
None => return None
impl CargoTestError {
#[allow(deprecated)] // connect => join in 1.3
pub fn new(errors: Vec<ProcessError>) -> Self {
- if errors.len() == 0 {
+ if errors.is_empty() {
panic!("Cannot create CargoTestError from empty Vec")
}
let desc = errors.iter().map(|error| error.desc.clone())
match *toml {
toml::Value::Table(ref table) => {
for (k, v) in table.iter() {
- add_unused_keys(m, v, if key.len() == 0 {
+ add_unused_keys(m, v, if key.is_empty() {
k.clone()
} else {
key.clone() + "." + k
} else {
self.diff_lines(a, e, partial)
};
- ham::expect(diffs.len() == 0,
+ ham::expect(diffs.is_empty(),
format!("differences:\n\
{}\n\n\
other output:\n\
}
}
}
- actual.len() == 0 || expected.ends_with("[..]")
+ actual.is_empty() || expected.ends_with("[..]")
}
struct ZipAll<I1: Iterator, I2: Iterator> {
let f = File::create(&dst).unwrap();
let a = Archive::new(GzEncoder::new(f, Default));
self.append(&a, "Cargo.toml", &manifest);
- if self.files.len() == 0 {
+ if self.files.is_empty() {
self.append(&a, "src/lib.rs", "");
} else {
for &(ref name, ref contents) in self.files.iter() {
projects / cargo.git / commitdiff